home *** CD-ROM | disk | FTP | other *** search
/ Varios Español / Varios Español.iso / CLIPP52 / TCBLLIB1.ZIP / IGETIMG.PRG < prev    next >
Text File  |  1993-11-29  |  19KB  |  459 lines
  1. /***
  2. *
  3. *  iGetImg.prg
  4. *
  5. *  Illustration of gets and images with Light Lib Images.
  6. *
  7. *  Copyright (c) 1993, DFL.
  8. *  All rights reserved.
  9. *
  10. */
  11.  
  12.  
  13. #include "Inkey.ch"
  14.  
  15. #include "llibi.ch"          //  Use Light Lib Images defines
  16. #include "llibitoo.ch"       //  Use Light Lib Images tools defines
  17. #include "llibg.ch"          //  Use Light Lib Graphics defines
  18. #include "llibgtoo.ch"       //  Use Light Lib Graphics tools defines
  19.  
  20. FIELD NAME,FIRSTNAME,SIZE,BIRTDATE,EYES,HAIR,ADDR1,ADDR2,CITY,STATE,COUNTRY,ZIP,PHONE,IMAGE016,IMAGE256
  21.  
  22. MEMVAR GetList
  23.  
  24. STATIC lIs256Color := .F.    // Manage 16 and 256 colors monitors
  25.  
  26. *
  27. FUNCTION GetImage()
  28.  
  29.    LOCAL nTop := 06
  30.    LOCAL nLeft := 02
  31.    LOCAL nBottom := 24
  32.    LOCAL nRight  := 75
  33.  
  34.    LOCAL nKey                // Keystroke
  35.    LOCAL lMore := .T.        // Loop control
  36.  
  37.    LOCAL aWinButtons  := {}  //  Arrays to handle buttons
  38.    LOCAL aVertScroll  := {}  //  and scrolls bars
  39.    LOCAL aHoriScroll  := {}  //
  40.    LOCAL aGetButtons  := {}  //  Arrays to handle gets buttons
  41.  
  42.                              // General savings
  43.    LOCAL xScreen     := SAVESCREEN( nTop, nLeft, nBottom, nRight)
  44.    LOCAL cColorSave  := SETCOLOR("N/W,W+/B,,G,W+/N")
  45.    LOCAL nCursoSave  := SETCURSOR(0)
  46.  
  47.                              // Browse pseudo object
  48.    LOCAL oBrowseImg  := ARRAY(BROWSE_IMG_SIZE)
  49.  
  50.    oBrowseImg:lIsStable      := .F.
  51.    oBrowseImg:nCurrentX      := 0
  52.    oBrowseImg:nCurrentY      := 0
  53.    oBrowseImg:nScaleX        := 0
  54.    oBrowseImg:nScaleY        := 0
  55.  
  56.                              // No image loaded, ptr are empty
  57.    oBrowseImg:aOriPtr        := {}
  58.    oBrowseImg:aDisPtr        := {}
  59.  
  60.                              // Compute display window pixels values
  61.    oBrowseImg:nWinDispX1     := FONT_SIZE_X * ( nRight  - 18 + 2 )
  62.    oBrowseImg:nWinDispY1     := FONT_SIZE_Y * ( nTop    +  3 + 3 )
  63.    oBrowseImg:nWinDispX2     := FONT_SIZE_X * ( nRight  -  2 - 3 ) - 1
  64.    oBrowseImg:nWinDispY2     := FONT_SIZE_Y * ( nTop    + 15 - 1 ) - 1
  65.    oBrowseImg:nWinDispWidth  := oBrowseImg:nWinDispX2 - oBrowseImg:nWinDispX1 + 1
  66.    oBrowseImg:nWinDispHeight := oBrowseImg:nWinDispY2 - oBrowseImg:nWinDispY1 + 1
  67.  
  68.                              // Fill the images to be browsed
  69.    oBrowseImg:aImgAvail      := {}
  70.    oBrowseImg:nImgInUse      := 0
  71.  
  72.                              // Set the block to standard apply key
  73.    oBrowseImg:bApplyKey      := { |oBrowse,nKey| ImgApplyKey( oBrowse, nKey ) }
  74.    oBrowseImg:aUdfShort      := { { | nStatus , nCall | lImgGauge( nStatus , nCall, .F., oBrowseImg ) } , 10 }
  75.    oBrowseImg:aUdfLong       := { { | nStatus , nCall | lImgGauge( nStatus , nCall, .T., oBrowseImg ) } , 20 }
  76.  
  77.                              // -LLIBG- Display 3D box
  78.    DISPBOX(nTop,nLeft,nBottom,nRight,LLG_BOX_GRAY_SQUARE)
  79.  
  80.                              // -LLIBG- Display 3D box
  81.    gFrame(oBrowseImg:nWinDispX1                   - 4 ,;
  82.           oBrowseImg:nWinDispY1                   - 4 ,;
  83.           oBrowseImg:nWinDispX2 + FONT_SIZE_X * 2 + 4 ,;
  84.           oBrowseImg:nWinDispY2 + FONT_SIZE_Y     + 4 ,;
  85.           7,15,8,4,4,4,4                               ;
  86.           )
  87.  
  88.  
  89.                              // Set gauge function
  90.    iSet( LLI_SET_UDF , oBrowseImg:aUdfShort )
  91.  
  92.                              // Open database
  93.    USE ('People.Dbf') NEW
  94.  
  95.                              // Create GETS
  96.    CreateGets(nTop+4,nLeft+4,aGetButtons)
  97.  
  98.    lIs256Color := gMode()[LLG_MODE_COLOR_MAX]==256
  99.  
  100.                              // Load first image
  101.    lLoadImgFile( oBrowseImg , ALLTRIM(IF(lIs256Color,IMAGE256,IMAGE016))+'.BMP' )
  102.  
  103.  
  104.  
  105.                           // -LLIBG- Add vertical scroll bar
  106.    @ (nRight-5)*FONT_SIZE_X                                             ,;
  107.      (nTop+6)*FONT_SIZE_Y                                               ,;
  108.      (nRight-3)*FONT_SIZE_X                                             ,;
  109.      (nTop+14)*FONT_SIZE_Y                                               ;
  110.      SCROLLBAR                                                           ;
  111.      STYLE BUTTON_TYPE_SCROLL_VERT                                       ;
  112.      ACTIONUP  { || NIL }                                                ;
  113.      ACTIONDN  { || NIL }                                                ;
  114.      ACTIONBAR { |nSens,nPercent| ImageVertBar(nSens,nPercent,oBrowseImg) }         ;
  115.      HANDLE aVertScroll                                                  ;
  116.      ATTACH aWinButtons
  117.  
  118.  
  119.                              // -LLIBG- Add horizontal scroll bar
  120.    @ (nRight-16)*FONT_SIZE_X                                            ,;
  121.      (nTop+14)*FONT_SIZE_Y                                              ,;
  122.      (nRight-5)*FONT_SIZE_X                                             ,;
  123.      (nTop+15)*FONT_SIZE_Y                                               ;
  124.      SCROLLBAR                                                           ;
  125.      STYLE BUTTON_TYPE_SCROLL_HORI                                       ;
  126.      ACTIONUP  { || NIL }                                                ;
  127.      ACTIONDN  { || NIL }                                                ;
  128.      ACTIONBAR { |nSens,nPercent| ImageHoriBar(nSens,nPercent,oBrowseImg) }         ;
  129.      HANDLE aHoriScroll                                                  ;
  130.      ATTACH aWinButtons
  131.  
  132.  
  133.                              // Add a close window button
  134.    @ nLeft*FONT_SIZE_X                       ,;
  135.      nTop *FONT_SIZE_Y                      ,,;
  136.      BUTTON                                   ;
  137.      STYLE BUTTON_TYPE_KEY                    ;
  138.      ACTION K_ESC                             ;
  139.      DISPLAYUP gBmpLoad("CLOSEWIN.BMU")       ;
  140.      DISPLAYDN gBmpLoad("CLOSEWIN.BMD")       ;
  141.      ATTACH aWinButtons
  142.  
  143.  
  144.                              // -LLIBG- Add an icon bar
  145.  
  146.  
  147.                              // -LLIBG- Add a button to allow user
  148.                              //         to quit
  149.    @ (nLeft+2 )*FONT_SIZE_X                  ,;
  150.      (nTop+1  )*FONT_SIZE_Y                 ,,;
  151.      BUTTON                                   ;
  152.      STYLE BUTTON_TYPE_KEY                    ;
  153.      ACTION K_ESC                             ;
  154.      ACCELERATOR "Q"                          ;
  155.      DISPLAYUP gBmpLoad("QUIT.BMU")           ;
  156.      DISPLAYDN gBmpLoad("QUIT.BMD")           ;
  157.      ATTACH aWinButtons
  158.  
  159.                              // -LLIBG- Add a button go top of file
  160.    @ ATAIL(aWinButton)[BUTTON_RIGHT]+1                                 ,;
  161.      ATAIL(aWinButton)[BUTTON_TOP]                                    ,,;
  162.      BUTTON                                                             ;
  163.      STYLE BUTTON_TYPE_RELEASE                                          ;
  164.      ACTION { || Skipper(K_HOME,oBrowseImg,aGetButtons) }               ;
  165.      ACCELERATOR K_ALT_H                                                ;
  166.      DISPLAYUP gBmpLoad("GOBEG.BMU")                                    ;
  167.      DISPLAYDN gBmpLoad("GOBEG.BMD")                                    ;
  168.      ATTACH aWinButtons
  169.  
  170.                              // -LLIBG- Add a button skip backward
  171.    @ ATAIL(aWinButton)[BUTTON_RIGHT]+1                                 ,;
  172.      ATAIL(aWinButton)[BUTTON_TOP]                                    ,,;
  173.      BUTTON                                                             ;
  174.      STYLE BUTTON_TYPE_RELEASE                                          ;
  175.      ACTION { || Skipper(K_UP,oBrowseImg,aGetButtons) }                 ;
  176.      ACCELERATOR K_ALT_P                                                ;
  177.      DISPLAYUP gBmpLoad("GOBAK.BMU")                                    ;
  178.      DISPLAYDN gBmpLoad("GOBAK.BMD")                                    ;
  179.      ATTACH aWinButtons
  180.  
  181.                              // -LLIBG- Add a button change values
  182.    @ ATAIL(aWinButton)[BUTTON_RIGHT]+1                                 ,;
  183.      ATAIL(aWinButton)[BUTTON_TOP]                                    ,,;
  184.      BUTTON                                                             ;
  185.      STYLE BUTTON_TYPE_RELEASE                                          ;
  186.      ACTION { || ReadGets(aGetButtons) }                                ;
  187.      ACCELERATOR K_ALT_C                                                ;
  188.      DISPLAYUP gBmpLoad("CHANGE.BMU")                                   ;
  189.      DISPLAYDN gBmpLoad("CHANGE.BMD")                                   ;
  190.      ATTACH aWinButtons
  191.  
  192.                              // -LLIBG- Add a button skip formward
  193.    @ ATAIL(aWinButton)[BUTTON_RIGHT]+1                                 ,;
  194.      ATAIL(aWinButton)[BUTTON_TOP]                                    ,,;
  195.      BUTTON                                                             ;
  196.      STYLE BUTTON_TYPE_RELEASE                                          ;
  197.      ACTION { || Skipper(K_DOWN,oBrowseImg,aGetButtons) }               ;
  198.      ACCELERATOR K_ALT_N                                                ;
  199.      DISPLAYUP gBmpLoad("GOFOR.BMU")                                    ;
  200.      DISPLAYDN gBmpLoad("GOFOR.BMD")                                    ;
  201.      ATTACH aWinButtons
  202.  
  203.                              // -LLIBG- Add a button bottom of file
  204.    @ ATAIL(aWinButton)[BUTTON_RIGHT]+1                                 ,;
  205.      ATAIL(aWinButton)[BUTTON_TOP]                                    ,,;
  206.      BUTTON                                                             ;
  207.      STYLE BUTTON_TYPE_RELEASE                                          ;
  208.      ACTION { || Skipper(K_END,oBrowseImg,aGetButtons) }                ;
  209.      ACCELERATOR K_ALT_E                                                ;
  210.      DISPLAYUP gBmpLoad("GOEND.BMU")                                    ;
  211.      DISPLAYDN gBmpLoad("GOEND.BMD")                                    ;
  212.      ATTACH aWinButtons
  213.  
  214.                              // -LLIBG- Add a button go fit image into
  215.                              //         the window
  216.    @ ATAIL(aWinButton)[BUTTON_RIGHT]+1                                 ,;
  217.      ATAIL(aWinButton)[BUTTON_TOP]                                    ,,;
  218.      BUTTON                                                             ;
  219.      STYLE BUTTON_TYPE_RELEASE                                          ;
  220.      ACTION { || ImgZoom(ASC('/'),oBrowseImg) }                         ;
  221.      ACCELERATOR "/"                                                    ;
  222.      DISPLAYUP gBmpLoad("SMALEST.BMU")                                  ;
  223.      DISPLAYDN gBmpLoad("SMALEST.BMD")                                  ;
  224.      ATTACH aWinButtons
  225.  
  226.                              // -LLIBG- Add a button to zoom a part of
  227.                              //         the image
  228.    @ ATAIL(aWinButton)[BUTTON_RIGHT]+1                                 ,;
  229.      ATAIL(aWinButton)[BUTTON_TOP]                                    ,,;
  230.      BUTTON                                                             ;
  231.      STYLE BUTTON_TYPE_RELEASE                                          ;
  232.      ACTION { || ImgZoom(ASC('°'),oBrowseImg) }                         ;
  233.      ACCELERATOR "°"                                                    ;
  234.      DISPLAYUP gBmpLoad("AREA.BMU")                                     ;
  235.      DISPLAYDN gBmpLoad("AREA.BMD")                                     ;
  236.      ATTACH aWinButtons
  237.  
  238.  
  239.                              // -LLIBG- Add a button to rotate to the right
  240.                              //         the image
  241.    @ ATAIL(aWinButton)[BUTTON_RIGHT]+1                                 ,;
  242.      ATAIL(aWinButton)[BUTTON_TOP]                                    ,,;
  243.      BUTTON                                                             ;
  244.      STYLE BUTTON_TYPE_RELEASE                                          ;
  245.      ACTION { || ImgRotate(90,oBrowseImg) }                             ;
  246.      ACCELERATOR "9"                                                    ;
  247.      DISPLAYUP gBmpLoad("ROTAT090.BMU")                                 ;
  248.      DISPLAYDN gBmpLoad("ROTAT090.BMD")                                 ;
  249.      ATTACH aWinButtons
  250.  
  251.                              // -LLIBG- Add a button to flip the image upside
  252.                              //         down
  253.    @ ATAIL(aWinButton)[BUTTON_RIGHT]+1                                 ,;
  254.      ATAIL(aWinButton)[BUTTON_TOP]                                    ,,;
  255.      BUTTON                                                             ;
  256.      STYLE BUTTON_TYPE_RELEASE                                          ;
  257.      ACTION { || ImgRotate(180,oBrowseImg) }                            ;
  258.      ACCELERATOR "1"                                                    ;
  259.      DISPLAYUP gBmpLoad("ROTAT180.BMU")                                 ;
  260.      DISPLAYDN gBmpLoad("ROTAT180.BMD")                                 ;
  261.      ATTACH aWinButtons
  262.  
  263.  
  264.                              // -LLIBG- Show all buttons defined
  265.    SHOW ALL BUTTONS aWinButtons
  266.  
  267.  
  268.    // Main loop
  269.    WHILE lMore
  270.  
  271.       IF !oBrowseImg:lIsStable .AND. NEXTKEY()==0
  272.  
  273.                              // Display image if not stable
  274.          ImgDynaDisplay(oBrowseImg)
  275.  
  276.       ENDIF
  277.  
  278.       IF oBrowseImg:lIsStable .AND. NEXTKEY()==0
  279.                           //         When the browse move, with K_UP,K_DOWN...
  280.                           //         we need to refresh scrollbars
  281.                           //         locations. Refresh only if no key pending
  282.          ScrBarUpDate(aHoriScroll,ImageHoriBar(NIL,NIL,oBrowseImg))
  283.          ScrBarUpDate(aVertScroll,ImageVertBar(NIL,NIL,oBrowseImg))
  284.  
  285.       ENDIF
  286.  
  287.       // Everything's done -- just wait for a key
  288.       nKey := mInkey( 0 , aWinButtons )
  289.                           // -LLIBG- Use mInkey() instead of INKEY() and
  290.                           //         add aWinButtons allow buttons management
  291.  
  292.  
  293.       IF ( nKey == K_ESC )
  294.          // Esc means leave
  295.          lMore := .F.
  296.  
  297.       ELSEIF ( nKey == K_BUTTON )   .OR. ;
  298.              ( nKey == K_CLIC_OUT ) .OR. ;
  299.              ( nKey == K_ACCELERATOR )
  300.  
  301.          // -LLIBG- Warning, when a button is hitted, mInkey() give the hand
  302.          //         back to main calling routine, and a value of K_BUTTON is
  303.          //         returned. We must not apply this K_BUTTON to applyKey
  304.          //         K_CLIC_OUT is returned when the clic does not match
  305.          //         any button. K_ACCELERATOR is returned when an accelerator
  306.          //         key have been striked
  307.          //         We dont need to apply these keys
  308.  
  309.       ELSE
  310.  
  311.          // Apply the key to the ImageBrowse
  312.          EVAL( oBrowseImg:bApplyKey, oBrowseImg, nKey )
  313.  
  314.       ENDIF
  315.  
  316.    ENDDO
  317.  
  318.  
  319.  
  320.    USE                       // Close database
  321.  
  322.                              // Erase VMM item
  323.    oBrowseImg:aDisPtr := iErase(oBrowseImg:aDisPtr)
  324.    oBrowseImg:aOriPtr := iErase(oBrowseImg:aOriPtr)
  325.  
  326.                              // General restoring
  327.    RESTSCREEN( nTop, nLeft, nBottom, nRight, xScreen)
  328.    SETCOLOR(cColorSave)
  329.    SETCURSOR(nCursoSave)
  330.  
  331.    RETURN (NIL)
  332.  
  333.  
  334.  
  335. *
  336. STATIC FUNCTION CreateGets(nRow        ,;  // Gets location in row/col
  337.                            nCol        ,;  //
  338.                            aGetButtons  ;  // Gets button handler
  339.                           )
  340.                              // Create gets for people file
  341.  
  342.    LOCAL nGetRow := nRow
  343.    LOCAL nBoxRow := nRow
  344.  
  345.    GetList := {}
  346.  
  347.                              // Create and display gets
  348.    @   nRow, nCol SAY "Name    :" GET Name
  349.    @ ++nRow, nCol SAY "First   :" GET FirstName
  350.    GetBox(nBoxRow,nCol,nRow,nCol+38,4,'Name')
  351.  
  352.    nRow++
  353.    nBoxRow := nRow + 1
  354.    @ ++nRow, nCol SAY "Addr.   :" GET Addr1
  355.    @ ++nRow, nCol SAY "         " GET Addr2
  356.    @ ++nRow, nCol SAY "City    :" GET City
  357.    @ ++nRow, nCol SAY "State   :" GET State
  358.    @ ++nRow, nCol SAY "Country :" GET Country
  359.    @ ++nRow, nCol SAY "Zip     :" GET Zip
  360.    @ ++nRow, nCol SAY "Phone   :" GET Phone
  361.    GetBox(nBoxRow,nCol,nRow,nCol+31,4,'Adresse')
  362.  
  363.    nRow := nGetRow+2
  364.    nBoxRow := nGetRow + 3
  365.    @ ++nRow, nCol+34 SAY "Size :" GET Size PICTURE '99999999' INCREMENTAL ATTACH aGetButtons
  366.    @ ++nRow, nCol+34 SAY "Born :" GET BirthDate INCREMENTAL ATTACH aGetButtons
  367.    @ ++nRow, nCol+34 SAY "Eyes :" GET Eyes RADIO 'Blue    ','Green   ','Brown   ' ATTACH aGetButtons
  368.    nRow+=2
  369.    @ ++nRow, nCol+34 SAY "Hairs:" GET Hair RADIO 'Blond   ','Brown   ' ATTACH aGetButtons
  370.    GetBox(nBoxRow,nCol+34,nRow+1,nCol+50,4,'Misc')
  371.  
  372.    GetBox(nGetRow,nCol,nRow+4,nCol+50,8,'')
  373.  
  374.  
  375.                              // Add a "CANCEL" button to emulate K_ESC
  376.    @ (nCol+10) * FONT_SIZE_X                 ,;
  377.      (nRow+03) * FONT_SIZE_Y                ,,;
  378.      BUTTON                                   ;
  379.      STYLE BUTTON_TYPE_KEY                    ;
  380.      ACTION K_ESC                             ;
  381.      ACCELERATOR K_ALT_L                      ;
  382.      DISPLAYUP gBmpLoad("CANCEL.BMU")         ;
  383.      DISPLAYDN gBmpLoad("CANCEL.BMD")         ;
  384.      ATTACH aGetButtons
  385.  
  386.                              // Add a "OK" button to emulate K_PGDN
  387.    @ (nCol+30) * FONT_SIZE_X                 ,;
  388.      (nRow+03) * FONT_SIZE_Y                ,,;
  389.      BUTTON                                   ;
  390.      STYLE BUTTON_TYPE_KEY                    ;
  391.      ACTION K_PGDN                            ;
  392.      ACCELERATOR K_ALT_O                      ;
  393.      DISPLAYUP gBmpLoad("OK.BMU")             ;
  394.      DISPLAYDN gBmpLoad("OK.BMD")             ;
  395.      ATTACH aGetButtons
  396.  
  397.  
  398.                              // Show all buttons connected to GET/READ
  399.    SHOW ALL BUTTONS aGetButtons
  400.  
  401.    RETURN (NIL)
  402.  
  403.  
  404. *
  405. STATIC FUNCTION ReadGets(aGetButtons)
  406.                              // Create gets for people file
  407.  
  408.    READ SAVE BUTTONS aGetButtons
  409.  
  410.    RETURN (NIL)
  411.  
  412. *
  413. STATIC FUNCTION Skipper( nKey ,oBrowseImg, aGetButtons )
  414.                              // Skip in DBF file
  415.  
  416.    LOCAL nOldRec := RECNO()  // Save recno to check real move
  417.  
  418.  
  419.    DO CASE
  420.  
  421.       CASE nKey  == K_HOME
  422.  
  423.            DBGOTOP()
  424.  
  425.       CASE nKey  == K_DOWN .AND. !EOF()
  426.  
  427.            DBSKIP(1)
  428.  
  429.            IF EOF()
  430.               DBSKIP(-1)
  431.            ENDIF
  432.  
  433.       CASE nKey  == K_UP .AND. !BOF()
  434.  
  435.            DBSKIP(-1)
  436.  
  437.       CASE nKey  == K_END
  438.  
  439.            DBGOBOTTOM()
  440.  
  441.    ENDCASE
  442.  
  443.  
  444.    IF nOldRec <> RECNO()     // If we really move
  445.  
  446.                              // Redisplay Gets
  447.       AEVAL(GetList,{ |el| el:display() })
  448.  
  449.                              // Redisplay buttons linked to gets
  450.       SHOW ALL BUTTONS aGetButtons
  451.                              // Load linked image
  452.       lLoadImgFile( oBrowseImg , ALLTRIM(IF(lIs256Color,IMAGE256,IMAGE016))+'.BMP' )
  453.  
  454.       oBrowseImg:lIsStable := .F.         // Image display is not stable
  455.  
  456.    ENDIF
  457.  
  458.    RETURN (NIL)
  459.